package com.tbynet.jwp.repository.impl;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.tbynet.jwp.framework.aop.Aop;
import com.tbynet.jwp.framework.core._JwpServiceProvider;
import com.tbynet.jwp.model.Options;
import com.tbynet.jwp.repository.spi.OptionService;

/**
 * 选项服务实现
 * &#064;ClassName:  OptionServiceProvider
 * &#064;Description:  负责选项数据的获取、添加、修改、删除功能的具体实现，职责单一
 * &#064;Author:  佰亿互联
 * &#064;Date:  2025年11月4日
 * &#064;Copyright:  2025 www.tbynet.com Inc. All rights reserved.
 * 注意: 本内容仅限于内部传阅，禁止外泄以及用于其他的商业目
 */
@Aop(OptionService.class)
public class OptionServiceImpl extends _JwpServiceProvider<Options> implements OptionService {

    @Override
    protected String buildSearchWhereSql(String keyword, List<Object> params) {
        return " WHERE 1=1"; // 选项表通常不需要搜索功能
    }

    /**
     * 根据选项名获取选项
     */
    @Override
    public Options getOption(String name) {
        return executeWithResultLogging("getOption", () -> {
            validateNotNull(name, "选项名不能为空");
            return getDao().findFirst("SELECT * FROM wp_options WHERE option_name = ? LIMIT 1", name);
        }, name);
    }

    /**
     * 根据选项名数组获取选项列表
     */
    @Override
    public List<Options> getOptions(String... names) {
        return executeWithResultLogging("getOptions", () -> {
            if (names == null || names.length == 0) {
                return Collections.emptyList();
            }

            List<Options> list = new ArrayList<>();
            for (String name : names) {
                Options option = getOption(name);
                if (option != null) {
                    list.add(option);
                }
            }
            return list;
        }, (Object) names);
    }

    /**
     * 获取选项值
     */
    @Override
    public String getOptionValue(String optionName) {
        return executeWithResultLogging("getOptionValue", () -> {
            validateNotNull(optionName, "选项名不能为空");
            Options option = getOption(optionName);
            return option != null ? option.getOptionValue() : null;
        }, optionName);
    }

    @Override
    public String getOptionValue(String optionName, String defaultValue) {
        return executeWithResultLogging("getOptionValueWithDefault", () -> {
            String value = getOptionValue(optionName);
            return value != null ? value : defaultValue;
        }, optionName, defaultValue);
    }

    @Override
    public boolean updateOption(String optionName, String optionValue) {
        return executeWithBooleanLogging("updateOption", () ->
                setOptionValue(optionName, optionValue), optionName, optionValue);
    }

    @Override
    public boolean addOption(String optionName, String optionValue) {
        return addOption(optionName, optionValue, true);
    }

    @Override
    public boolean addOption(String optionName, String optionValue, boolean autoload) {
        return executeWithBooleanLogging("addOption", () -> {
            validateNotNull(optionName, "选项名不能为空");
            validateNotNull(optionValue, "选项值不能为空");

            if (optionExists(optionName)) {
                return false; // 选项已存在，添加失败
            }

            Options option = new Options();
            option.setOptionName(optionName);
            option.setOptionValue(optionValue);
            option.setAutoload(autoload ? "yes" : "no");
            return option.save();
        }, optionName, optionValue, autoload);
    }

    @Override
    public boolean deleteOption(String optionName) {
        return executeWithBooleanLogging("deleteOption", () -> {
            validateNotNull(optionName, "选项名不能为空");
            Options option = getOption(optionName);
            if (option != null) {
                return option.delete();
            }
            return true; // 选项不存在，也算删除成功
        }, optionName);
    }

    @Override
    public boolean optionExists(String optionName) {
        return executeWithBooleanLogging("optionExists", () -> {
            validateNotNull(optionName, "选项名不能为空");
            Options option = getOption(optionName);
            return option != null;
        }, optionName);
    }

    @Override
    public Map<String, String> getOptionsMap(String... optionNames) {
        return executeWithResultLogging("getOptionsMap", () -> {
            if (optionNames == null || optionNames.length == 0) {
                return Collections.emptyMap();
            }

            Map<String, String> result = new HashMap<>();
            for (String name : optionNames) {
                String value = getOptionValue(name);
                if (value != null) {
                    result.put(name, value);
                }
            }
            return result;
        }, (Object) optionNames);
    }

    @Override
    public boolean updateOptions(Map<String, String> options) {
        return executeWithBooleanLogging("updateOptions", () -> {
            if (options == null || options.isEmpty()) {
                return true;
            }

            boolean allSuccess = true;
            for (Map.Entry<String, String> entry : options.entrySet()) {
                boolean success = setOptionValue(entry.getKey(), entry.getValue());
                if (!success) {
                    allSuccess = false;
                    log.warn("更新选项失败: %s", entry.getKey());
                }
            }
            return allSuccess;
        }, options != null ? options.size() : 0);
    }

    @Override
    public Map<String, String> getAllAutoloadOptions() {
        return executeWithResultLogging("getAllAutoloadOptions", () -> {
            List<Options> autoloadOptions = getDao().find(
                    "SELECT option_name, option_value FROM wp_options WHERE autoload = 'yes'"
            );

            Map<String, String> result = new HashMap<>();
            for (Options option : autoloadOptions) {
                result.put(option.getOptionName(), option.getOptionValue());
            }
            return result;
        });
    }

    // ========== 站点信息选项实现 ==========

    @Override
    public String getSiteUrl() {
        return getOptionValue("siteurl");
    }

    @Override
    public String getHomeUrl() {
        return getOptionValue("home");
    }

    @Override
    public String getBlogName() {
        return getOptionValue("blogname");
    }

    @Override
    public String getBlogDescription() {
        return getOptionValue("blogdescription");
    }

    @Override
    public String getAdminEmail() {
        return getOptionValue("admin_email");
    }

    @Override
    public String getTimezone() {
        return getOptionValue("timezone_string");
    }

    @Override
    public String getDateFormat() {
        return getOptionValue("date_format", "Y-m-d");
    }

    @Override
    public String getTimeFormat() {
        return getOptionValue("time_format", "H:i:s");
    }

    // ========== 阅读设置选项实现 ==========

    @Override
    public int getPostsPerPage() {
        return executeWithResultLogging("getPostsPerPage", () ->
                getOptionValueAsInt("posts_per_page", 10));
    }

    @Override
    public int getPostsPerRss() {
        return executeWithResultLogging("getPostsPerRss", () ->
                getOptionValueAsInt("posts_per_rss", 10));
    }

    @Override
    public String getRssUseExcerpt() {
        return getOptionValue("rss_use_excerpt", "0");
    }

    @Override
    public String getShowOnFront() {
        return getOptionValue("show_on_front", "posts");
    }

    @Override
    public Integer getPageOnFront() {
        return executeWithResultLogging("getPageOnFront", () ->
                getOptionValueAsInteger("page_on_front"));
    }

    @Override
    public Integer getPageForPosts() {
        return executeWithResultLogging("getPageForPosts", () ->
                getOptionValueAsInteger("page_for_posts"));
    }

    // ========== 讨论设置选项实现 ==========

    @Override
    public String getDefaultCommentStatus() {
        return getOptionValue("default_comment_status", "open");
    }

    @Override
    public String getDefaultPingStatus() {
        return getOptionValue("default_ping_status", "open");
    }

    @Override
    public boolean isCommentModeration() {
        return executeWithBooleanLogging("isCommentModeration", () ->
                "1".equals(getOptionValue("comment_moderation", "0")));
    }

    @Override
    public int getCommentMaxLinks() {
        return executeWithResultLogging("getCommentMaxLinks", () ->
                getOptionValueAsInt("comment_max_links", 2));
    }

    @Override
    public String getCommentBlacklistKeys() {
        return getOptionValue("blacklist_keys", "");
    }

    // ========== 媒体设置选项实现 ==========

    @Override
    public int[] getThumbnailSize() {
        return executeWithResultLogging("getThumbnailSize", () -> {
            int width = getOptionValueAsInt("thumbnail_size_w", 150);
            int height = getOptionValueAsInt("thumbnail_size_h", 150);
            String crop = getOptionValue("thumbnail_crop", "1");
            return new int[]{width, height, "1".equals(crop) ? 1 : 0};
        });
    }

    @Override
    public int[] getMediumSize() {
        return executeWithResultLogging("getMediumSize", () -> {
            int width = getOptionValueAsInt("medium_size_w", 300);
            int height = getOptionValueAsInt("medium_size_h", 300);
            return new int[]{width, height};
        });
    }

    @Override
    public int[] getLargeSize() {
        return executeWithResultLogging("getLargeSize", () -> {
            int width = getOptionValueAsInt("large_size_w", 1024);
            int height = getOptionValueAsInt("large_size_h", 1024);
            return new int[]{width, height};
        });
    }

    @Override
    public String getUploadsUseYearmonthFolders() {
        return getOptionValue("uploads_use_yearmonth_folders", "1");
    }

    // ========== 固定链接设置选项实现 ==========

    @Override
    public String getPermalinkStructure() {
        return getOptionValue("permalink_structure", "");
    }

    @Override
    public String getCategoryBase() {
        return getOptionValue("category_base", "category");
    }

    @Override
    public String getTagBase() {
        return getOptionValue("tag_base", "tag");
    }

    // ========== 主题和外观选项实现 ==========

    @Override
    public String getCurrentTheme() {
        return getOptionValue("template");
    }

    @Override
    public String getStylesheet() {
        return getOptionValue("stylesheet");
    }

    @Override
    public long getThemeMods() {
        return executeWithResultLogging("getThemeMods", () ->
                getOptionValueAsLong("theme_mods_" + getCurrentTheme(), 0L));
    }

    // ========== 小工具和菜单选项实现 ==========

    @Override
    public String getSidebarWidgets() {
        return getOptionValue("sidebars_widgets");
    }

    @Override
    public String getNavMenuOptions() {
        return getOptionValue("nav_menu_options");
    }

    // ========== 用户和权限选项实现 ==========

    @Override
    public boolean canUsersRegister() {
        return executeWithBooleanLogging("canUsersRegister", () ->
                "1".equals(getOptionValue("users_can_register", "0")));
    }

    @Override
    public String getDefaultUserRole() {
        return getOptionValue("default_role", "subscriber");
    }

    @Override
    public boolean isShowAvatars() {
        return executeWithBooleanLogging("isShowAvatars", () ->
                "1".equals(getOptionValue("show_avatars", "1")));
    }

    /**
     * 设置选项值（单一职责）
     */
    @Override
    public boolean setOptionValue(String optionName, String optionValue) {
        return executeWithBooleanLogging("setOptionValue", () -> {
            validateNotNull(optionName, "选项名不能为空");
            validateNotNull(optionValue, "选项值不能为空");

            try {
                Options option = getOption(optionName);
                if (option == null) {
                    // 创建新选项
                    option = new Options();
                    option.setOptionName(optionName);
                    option.setOptionValue(optionValue);
                    option.setAutoload("yes");
                    return option.save();
                } else {
                    // 更新现有选项
                    option.setOptionValue(optionValue);
                    return option.update();
                }
            } catch (Exception e) {
                log.error("设置选项值失败，选项名：%s", optionName, e);
                return false;
            }
        }, optionName, optionValue);
    }

    /**
     * 添加置顶文章（单一职责）
     */
    @Override
    public boolean addStickyPost(Object postId) {
        return executeWithBooleanLogging("addStickyPost", () -> {
            validateNotNull(postId, "文章ID不能为空");

            try {
                Options option = getOption(Options.sticky_posts);
                if (option == null) {
                    // 创建置顶文章选项
                    option = new Options();
                    option.setOptionName(Options.sticky_posts);
                    option.setAutoload("yes");
                }

                Integer postIdInt = ((Number) postId).intValue();
                option.addStickyPost(postIdInt);

                if (option.getOptionId() == null) {
                    return option.save();
                } else {
                    return option.update();
                }
            } catch (Exception e) {
                log.error("添加置顶文章失败，文章ID：%s", postId, e);
                return false;
            }
        }, postId);
    }

    /**
     * 移除置顶文章（单一职责）
     */
    @Override
    public boolean removeStickyPost(Object postId) {
        return executeWithBooleanLogging("removeStickyPost", () -> {
            validateNotNull(postId, "文章ID不能为空");

            try {
                Options option = getOption(Options.sticky_posts);
                if (option != null) {
                    Integer postIdInt = ((Number) postId).intValue();
                    option.removeStickyPost(postIdInt);
                    return option.update();
                }
                return true; // 如果没有置顶选项，也算成功
            } catch (Exception e) {
                log.error("移除置顶文章失败，文章ID：%s", postId, e);
                return false;
            }
        }, postId);
    }

    /**
     * 检查文章是否置顶（单一职责）
     */
    @Override
    public boolean isStickyPost(Object postId) {
        return executeWithBooleanLogging("isStickyPost", () -> {
            validateNotNull(postId, "文章ID不能为空");

            try {
                Options option = getOption(Options.sticky_posts);
                if (option != null) {
                    Integer postIdInt = ((Number) postId).intValue();
                    return option.hasStickyPost(postIdInt);
                }
                return false;
            } catch (Exception e) {
                log.error("检查置顶文章失败，文章ID：%s", postId, e);
                return false;
            }
        }, postId);
    }

    /**
     * 获取所有置顶文章ID列表
     */
    @Override
    public List<Integer> getStickyPosts() {
        return executeWithResultLogging("getStickyPosts", () -> {
            Options option = getOption(Options.sticky_posts);
            return option != null ? option.getStickyPosts() : new ArrayList<>();
        });
    }

    // ========== 缓存和性能选项实现 ==========

    @Override
    public String getOptionCacheVersion() {
        return getOptionValue("option_cache_version", "1");
    }

    @Override
    public boolean clearOptionCache() {
        return executeWithBooleanLogging("clearOptionCache", () -> {
            // 这里可以实现具体的缓存清除逻辑
            log.info("选项缓存已清除");
            return true;
        });
    }

    @Override
    public boolean reloadAutoloadOptions() {
        return executeWithBooleanLogging("reloadAutoloadOptions", () -> {
            // 重新加载自动加载选项到缓存
            getAllAutoloadOptions(); // 这会触发重新加载
            log.info("自动加载选项已重新加载");
            return true;
        });
    }

    // ========== 高级选项操作实现 ==========

    @Override
    public String serializeOptionValue(Object value) {
        return executeWithResultLogging("serializeOptionValue", () -> {
            if (value == null) {
                return "";
            }
            // 简单的序列化实现，实际可以使用JSON或其他序列化方式
            if (value instanceof String) {
                return (String) value;
            }
            return value.toString();
        }, value != null ? value.getClass().getSimpleName() : "null");
    }

    @Override
    public Object unserializeOptionValue(String value) {
        return executeWithResultLogging("unserializeOptionValue", () -> {
            if (value == null || value.isEmpty()) {
                return null;
            }
            // 简单的反序列化实现
            return value;
        }, value);
    }

    @Override
    public boolean isOptionAutoload(String optionName) {
        return executeWithBooleanLogging("isOptionAutoload", () -> {
            validateNotNull(optionName, "选项名不能为空");
            Options option = getOption(optionName);
            return option != null && "yes".equals(option.getAutoload());
        }, optionName);
    }

    @Override
    public boolean setOptionAutoload(String optionName, boolean autoload) {
        return executeWithBooleanLogging("setOptionAutoload", () -> {
            validateNotNull(optionName, "选项名不能为空");
            Options option = getOption(optionName);
            if (option != null) {
                option.setAutoload(autoload ? "yes" : "no");
                return option.update();
            }
            return false;
        }, optionName, autoload);
    }

    // ========== 系统维护选项实现 ==========

    @Override
    public boolean isSiteInMaintenance() {
        return executeWithBooleanLogging("isSiteInMaintenance", () ->
                "1".equals(getOptionValue("maintenance_mode", "0")));
    }

    @Override
    public boolean setSiteMaintenance(boolean maintenance, String message) {
        return executeWithBooleanLogging("setSiteMaintenance", () -> {
            boolean success = setOptionValue("maintenance_mode", maintenance ? "1" : "0");
            if (success && message != null) {
                setOptionValue("maintenance_message", message);
            }
            return success;
        }, maintenance, message);
    }

    @Override
    public String getDatabaseVersion() {
        return getOptionValue("db_version");
    }

    @Override
    public String getWordPressVersion() {
        return getOptionValue("version");
    }

    // ========== 私有工具方法 ==========

    /**
     * 获取选项值并转换为整数
     */
    private int getOptionValueAsInt(String optionName, int defaultValue) {
        String value = getOptionValue(optionName);
        if (value == null) {
            return defaultValue;
        }
        try {
            return Integer.parseInt(value);
        } catch (NumberFormatException e) {
            log.warn("选项 %s 格式错误: %s", optionName, value);
            return defaultValue;
        }
    }

    /**
     * 获取选项值并转换为整数（可空）
     */
    private Integer getOptionValueAsInteger(String optionName) {
        String value = getOptionValue(optionName);
        if (value == null) {
            return null;
        }
        try {
            return Integer.parseInt(value);
        } catch (NumberFormatException e) {
            log.warn("选项 %s 格式错误: %s", optionName, value);
            return null;
        }
    }

    /**
     * 获取选项值并转换为长整数
     */
    private long getOptionValueAsLong(String optionName, long defaultValue) {
        String value = getOptionValue(optionName);
        if (value == null) {
            return defaultValue;
        }
        try {
            return Long.parseLong(value);
        } catch (NumberFormatException e) {
            log.warn("选项 %s 格式错误: %s", optionName, value);
            return defaultValue;
        }
    }
}